/**
 * 动态技能描述系统
 * 根据技能等级、永久提升等实时生成技能描述
 */

import rpg_component from '../../../component/rpg_component';
import { SkillType, TargetType } from '../../../shared/face/enums';
import BattleLogger from '../BattleLogger';

/**
 * 技能描述模板接口
 */
export interface ISkillDescriptionTemplate {
    /** 基础描述模板 */
    baseTemplate: string;
    
    /** 等级描述模板 */
    levelTemplate?: string;
    
    /** 永久提升描述模板 */
    permanentBoostTemplate?: string;
    
    /** 冷却描述模板 */
    cooldownTemplate?: string;
    
    /** 效果计算函数 */
    effectCalculator?: (skill: any, caster?: any) => number;
}

/**
 * 动态技能描述管理器
 */
export class DynamicSkillDescription {
    /** 描述模板缓存 */
    private descriptionTemplates: Map<string, ISkillDescriptionTemplate> = new Map();
    
    /** 默认模板 */
    private defaultTemplates: Map<SkillType, ISkillDescriptionTemplate> = new Map();

    constructor() {
        this.initializeDefaultTemplates();
    }

    /**
     * 初始化默认模板
     */
    private initializeDefaultTemplates(): void {
        // 主动技能默认模板
        this.defaultTemplates.set(SkillType.主动技能, {
            baseTemplate: '对目标造成{effect}点{damageType}伤害',
            levelTemplate: '(等级{level})',
            permanentBoostTemplate: '，每次使用后{boostType}永久提升{boostAmount}点',
            cooldownTemplate: '(冷却{cooldown}回合)',
            effectCalculator: (skill: any, caster?: any) => {
                return this.calculateSkillEffect(skill, caster);
            }
        });

        // 被动技能默认模板
        this.defaultTemplates.set(SkillType.被动技能, {
            baseTemplate: '被动效果：{effect}',
            levelTemplate: '(等级{level})',
            permanentBoostTemplate: '，每次触发后{boostType}永久提升{boostAmount}点'
        });

        // 光环技能默认模板
        this.defaultTemplates.set(SkillType.光环技能, {
            baseTemplate: '光环效果：{effect}',
            levelTemplate: '(等级{level})',
            permanentBoostTemplate: '，每次使用后{boostType}永久提升{boostAmount}点'
        });
    }

    /**
     * 注册技能描述模板
     * @param skillId 技能ID
     * @param template 描述模板
     */
    public registerTemplate(skillId: string, template: ISkillDescriptionTemplate): void {
        this.descriptionTemplates.set(skillId, template);
        BattleLogger.log('info', '技能描述模板注册成功', { skillId, template });
    }

    /**
     * 生成技能描述
     * @param skill 技能对象
     * @param caster 施法者（可选）
     * @returns 生成的描述
     */
    public generateDescription(skill: any, caster?: rpg_component): string {
        // 优先使用技能配置中的desc字段
        if (skill.desc) {
            let description = this.replaceBasicVariables(skill.desc, skill, caster);
            
            // 所有技能都显示等级信息（如果等级大于1）
            let skillLevel = skill.level || 1;
            if (caster) {
                const skillUseData = caster.getSkillUseData?.(skill.id);
                if (skillUseData) {
                    skillLevel = skillUseData.level || 1;
                }
            }
            
            // 所有技能都显示等级信息
            if (skillLevel > 1) {
                description += ` (等级${skillLevel})`;
            }
            
            return description;
        }

        const template = this.descriptionTemplates.get(skill.id) || 
                        this.defaultTemplates.get(skill.type);

        if (!template) {
            return this.generateDefaultDescription(skill, caster);
        }

        let description = template.baseTemplate;

        // 替换基础变量
        description = this.replaceBasicVariables(description, skill, caster);

        // 添加等级信息
        let skillLevel = skill.level || 1;
        if (caster) {
            const skillUseData = caster.getSkillUseData?.(skill.id);
            if (skillUseData) {
                skillLevel = skillUseData.level || 1;
            }
        }
        
        // 所有技能都显示等级信息
        if (template.levelTemplate && skillLevel > 1) {
            // 临时设置技能等级，用于模板替换
            const originalLevel = skill.level;
            skill.level = skillLevel;
            const levelDesc = this.replaceBasicVariables(template.levelTemplate, skill, caster);
            skill.level = originalLevel; // 恢复原始值
            description += ` ${levelDesc}`;
        }

        // 添加永久提升信息
        if (template.permanentBoostTemplate && this.hasPermanentBoost(skill)) {
            const boostDesc = this.replacePermanentBoostVariables(template.permanentBoostTemplate, skill, caster);
            description += boostDesc;
        }

        // 添加冷却信息
        if (template.cooldownTemplate && skill.cooldown > 0) {
            const cooldownDesc = this.replaceBasicVariables(template.cooldownTemplate, skill, caster);
            description += ` ${cooldownDesc}`;
        }

        return description;
    }

    /**
     * 替换基础变量
     * @param template 模板字符串
     * @param skill 技能对象
     * @param caster 施法者
     * @returns 替换后的字符串
     */
    private replaceBasicVariables(template: string, skill: any, caster?: any): string {
        let result = template;

        // 替换效果数值 - 支持 {effect} 和 {effect.0}, {effect.1} 等格式
        const effectRegex = /\{effect(?:\.(\d+))?\}/g;
        result = result.replace(effectRegex, (match, index) => {
            const effectIndex = index ? parseInt(index) : 0;
            const effect = this.calculateSkillEffect(skill, caster, effectIndex);
            return String(effect);
        });

        // 替换伤害类型
        if (result.includes('{damageType}')) {
            const damageType = this.getDamageType(skill);
            result = result.replace(/{damageType}/g, damageType);
        }

        // 替换等级
        if (result.includes('{level}')) {
            result = result.replace(/{level}/g, String(skill.level || 1));
        }

        // 替换冷却
        if (result.includes('{cooldown}')) {
            result = result.replace(/{cooldown}/g, String(skill.cooldown || 0));
        }

        // 替换永久提升变量 - 支持 {boostAmount.xxx} 格式
        result = this.replaceBoostAmountVariables(result, skill, caster);

        // 替换所有效果描述
        if (result.includes('{effects}')) {
            const effectsDesc = this.generateEffectsDescription(skill, caster);
            result = result.replace(/{effects}/g, effectsDesc);
        }

        return result;
    }

    /**
     * 生成所有效果的描述
     * @param skill 技能对象
     * @param caster 施法者（可选）
     * @returns 效果描述字符串
     */
    private generateEffectsDescription(skill: any, caster?: any): string {
        if (!skill.data || skill.data.length === 0) {
            return '无效果';
        }

        const effects: string[] = [];

        for (let i = 0; i < skill.data.length; i++) {
            const skillData = skill.data[i];
            const effectValue = this.calculateSkillEffect(skill, caster, i);
            
            // 根据效果类型生成描述
            if (skillData.fixed || skillData.attRange) {
                // 伤害或治疗效果
                const damageType = this.getDamageTypeForEffect(skillData);
                effects.push(`${effectValue}点${damageType}伤害`);
            } else if (skillData.shield) {
                // 护盾效果
                effects.push(`${skillData.shield}点护盾`);
            } else if (skillData.healing) {
                // 治疗效果
                effects.push(`${skillData.healing}点治疗`);
            } else if (skillData.addBuffName) {
                // Buff效果
                effects.push(`添加${skillData.addBuffName}效果`);
            } else {
                // 其他效果
                effects.push('特殊效果');
            }
        }

        return effects.join('，');
    }

    /**
     * 获取效果对应的伤害类型
     * @param skillData 技能数据
     * @returns 伤害类型
     */
    private getDamageTypeForEffect(skillData: any): string {
        switch (skillData.attKey) {
            case '物理攻击':
                return '物理';
            case '魔法攻击':
                return '魔法';
            case '真实攻击':
                return '真实';
            case '恢复生命':
                return '治疗';
            default:
                return '物理';
        }
    }

    /**
     * 替换永久提升数值变量
     * @param template 模板字符串
     * @param skill 技能对象
     * @param caster 施法者（可选）
     * @returns 替换后的字符串
     */
    private replaceBoostAmountVariables(template: string, skill: any, caster?: any): string {
        let result = template;

        // 匹配 {boostAmount.xxx} 格式的变量
        const boostAmountRegex = /\{boostAmount\.(\w+)\}/g;
        
        result = result.replace(boostAmountRegex, (match, boostType) => {
            // 获取累积的永久提升数值
            let cumulativeBoost = 0;
            
            // 如果有施法者，获取累积的永久提升
            if (caster) {
                const skillUseData = caster.getSkillUseData?.(skill.id);
                if (skillUseData && skillUseData.permanentBoosts) {
                    cumulativeBoost = skillUseData.permanentBoosts[boostType] || 0;
                }
            }
            
            return String(cumulativeBoost);
        });

        return result;
    }

    /**
     * 替换永久提升变量
     * @param template 模板字符串
     * @param skill 技能对象
     * @param caster 施法者（可选）
     * @returns 替换后的字符串
     */
    private replacePermanentBoostVariables(template: string, skill: any, caster?: any): string {
        let result = template;

        const permanentBoost = this.getPermanentBoost(skill);
        if (permanentBoost) {
            result = result.replace(/{boostType}/g, this.getBoostTypeName(permanentBoost.type));
            
            // 获取累积的永久提升数值
            let cumulativeBoost = permanentBoost.amount; // 基础数值
            
            // 如果有施法者，获取累积的永久提升
            if (caster) {
                const skillUseData = caster.getSkillUseData?.(skill.id);
                if (skillUseData && skillUseData.permanentBoosts) {
                    const cumulativeAmount = skillUseData.permanentBoosts[permanentBoost.type] || 0;
                    cumulativeBoost = cumulativeAmount;
                }
            }
            
            result = result.replace(/{boostAmount}/g, String(cumulativeBoost));
        }

        return result;
    }

    /**
     * 计算技能效果数值
     * @param skill 技能对象
     * @param caster 施法者（可选，仅用于获取技能使用数据）
     * @param effectIndex 效果索引（用于支持多个效果）
     * @returns 效果数值
     */
    private calculateSkillEffect(skill: any, caster?: any, effectIndex: number = 0): number {
        // 基础效果
        let baseEffect = 0;
        
        if (skill.data && skill.data.length > effectIndex) {
            const skillData = skill.data[effectIndex];
            
            // 只计算固定伤害，不依赖施法者属性
            if (skillData.fixed) {
                baseEffect += skillData.fixed;
            }
            
            // 如果有攻击倍率，使用默认攻击力计算（不依赖施法者）
            if (skillData.attRange) {
                const defaultAttackValue = this.getDefaultAttackValue(skillData.attKey);
                baseEffect += defaultAttackValue * skillData.attRange;
            }
        }

        // 从施法者获取技能等级和永久提升
        let level = 1;
        let permanentBoosts: { [key: string]: number } = {};
        
        if (caster) {
            const skillUseData = caster.getSkillUseData?.(skill.id);
            if (skillUseData) {
                level = skillUseData.level || 1;
                permanentBoosts = skillUseData.permanentBoosts || {};
            }
        }

        // 所有技能都应用等级加成
        const levelMultiplier = 1 + (level - 1) * 0.1;
        baseEffect *= levelMultiplier;
        
        // 如果有levelUpBoost配置，应用额外的升级属性加成
        if (skill.data && skill.data.length > 0) {
            const firstEffect = skill.data[0];
            if (firstEffect.levelUpBoost) {
                // 应用levelUpBoost中配置的属性加成
                if (firstEffect.levelUpBoost.attRange) {
                    // 计算累积的attRange提升（每次升级提升的数值 × 升级次数）
                    const attRangeBoost = firstEffect.levelUpBoost.attRange * (level - 1);
                    const defaultAttackValue = this.getDefaultAttackValue(firstEffect.attKey);
                    baseEffect += defaultAttackValue * attRangeBoost;
                }
                
                if (firstEffect.levelUpBoost.damage) {
                    // 计算累积的damage提升
                    const damageBoost = firstEffect.levelUpBoost.damage * (level - 1);
                    baseEffect += damageBoost;
                }
            }
        }

        // 永久提升（来自技能使用后的累积提升）
        if (permanentBoosts.damage) {
            baseEffect += permanentBoosts.damage;
        }
        if (permanentBoosts.attRange) {
            const defaultAttackValue = this.getDefaultAttackValue(skill.data?.[0]?.attKey || '物理攻击');
            baseEffect += defaultAttackValue * permanentBoosts.attRange;
        }

        return Math.round(baseEffect);
    }

    /**
     * 获取攻击力数值
     * @param attackKey 攻击类型
     * @param caster 施法者
     * @returns 攻击力数值
     */
    private getAttackValue(attackKey: string, caster: any): number {
        if (!caster || !caster.getAttribute) {
            return 0;
        }

        switch (attackKey) {
            case '物理攻击':
                return caster.getAttribute('物理攻击') || 0;
            case '魔法攻击':
                return caster.getAttribute('魔法攻击') || 0;
            case '真实攻击':
                return caster.getAttribute('真实攻击') || 0;
            default:
                return 0;
        }
    }

    /**
     * 获取默认攻击力数值（用于技能描述，不依赖施法者属性）
     * @param attackKey 攻击类型
     * @returns 默认攻击力数值
     */
    private getDefaultAttackValue(attackKey: string): number {
        // 使用固定的默认攻击力，确保技能描述一致
        switch (attackKey) {
            case '物理攻击':
                return 50; // 默认物理攻击力
            case '魔法攻击':
                return 60; // 默认魔法攻击力
            case '真实攻击':
                return 40; // 默认真实攻击力
            default:
                return 50;
        }
    }

    /**
     * 获取伤害类型名称
     * @param skill 技能对象
     * @returns 伤害类型名称
     */
    private getDamageType(skill: any): string {
        if (skill.data && skill.data.length > 0) {
            const skillData = skill.data[0];
            switch (skillData.attKey) {
                case '物理攻击':
                    return '物理';
                case '魔法攻击':
                    return '魔法';
                case '真实攻击':
                    return '真实';
                default:
                    return '物理';
            }
        }
        return '物理';
    }

    /**
     * 检查是否有永久提升
     * @param skill 技能对象
     * @returns 是否有永久提升
     */
    private hasPermanentBoost(skill: any): boolean {
        if (skill.data && skill.data.length > 0) {
            const skillData = skill.data[0];
            return skillData.permanentBoost !== undefined;
        }
        return false;
    }

    /**
     * 获取永久提升配置
     * @param skill 技能对象
     * @returns 永久提升配置
     */
    private getPermanentBoost(skill: any): any {
        if (skill.data && skill.data.length > 0) {
            const skillData = skill.data[0];
            return skillData.permanentBoost;
        }
        return null;
    }

    /**
     * 获取提升类型名称
     * @param boostType 提升类型
     * @returns 提升类型名称
     */
    private getBoostTypeName(boostType: string): string {
        switch (boostType) {
            case 'damage':
                return '伤害';
            case 'attRange':
                return '攻击倍率';
            case 'cooldown':
                return '冷却时间';
            default:
                return boostType;
        }
    }

    /**
     * 生成默认描述
     * @param skill 技能对象
     * @param caster 施法者
     * @returns 默认描述
     */
    private generateDefaultDescription(skill: any, caster?: any): string {
        let description = skill.desc || skill.name;

        // 添加等级信息
        if (skill.level > 1) {
            description += ` (等级 ${skill.level})`;
        }

        // 添加效果信息
        const effect = this.calculateSkillEffect(skill, caster);
        if (effect > 0) {
            description += ` (伤害 ${effect})`;
        }

        return description;
    }

    /**
     * 更新技能描述
     * @param skill 技能对象
     * @param caster 施法者
     */
    public updateSkillDescription(skill: any, caster?: any): void {
        const newDescription = this.generateDescription(skill, caster);
        
        // 更新技能描述
        if (skill.desc !== newDescription) {
            const oldDescription = skill.desc;
            skill.desc = newDescription;
            
            BattleLogger.log('info', '技能描述已更新', {
                skillId: skill.id,
                skillName: skill.name,
                oldDescription,
                newDescription
            });
        }
    }

    /**
     * 获取所有可用变量
     * @returns 可用变量列表
     */
    public getAvailableVariables(): string[] {
        return [
            '{effect}',
            '{damageType}',
            '{level}',
            '{cooldown}',
            '{boostType}',
            '{boostAmount}'
        ];
    }

    /**
     * 生成条件触发永久提升的描述
     * @param skill 技能对象
     * @returns 条件描述字符串
     */
    private generateConditionDescription(skill: any): string {
        if (!skill.data || skill.data.length === 0) {
            return '';
        }

        const conditions: string[] = [];

        for (const skillData of skill.data) {
            if (skillData.permanentBoost) {
                const boost = skillData.permanentBoost;
                const conditionDesc = boost.conditionDesc || this.getDefaultConditionDescription(boost.condition);
                
                if (conditionDesc) {
                    conditions.push(conditionDesc);
                }
            }
        }

        return conditions.length > 0 ? `，${conditions.join('，')}` : '';
    }

    /**
     * 获取默认条件描述
     * @param condition 条件类型
     * @returns 条件描述
     */
    private getDefaultConditionDescription(condition?: string): string {
        switch (condition) {
            case 'always':
                return '每次使用时';
            case 'kill':
                return '击杀敌人时';
            case 'critical':
                return '暴击时';
            case 'dodge':
                return '闪避时';
            case 'damage_threshold':
                return '造成高伤害时';
            case 'health_threshold':
                return '生命值较低时';
            case 'combo':
                return '连击时';
            default:
                return '满足条件时';
        }
    }
}

// 导出单例实例
export const dynamicSkillDescription = new DynamicSkillDescription(); 